package de.sabram.upb.specs.serializer;

import com.google.inject.Inject;
import com.google.inject.Provider;
import de.sabram.upb.specs.lido.Alt;
import de.sabram.upb.specs.lido.Alts;
import de.sabram.upb.specs.lido.Attr;
import de.sabram.upb.specs.lido.AttrDefId;
import de.sabram.upb.specs.lido.AttrDefIds;
import de.sabram.upb.specs.lido.AttrDefs;
import de.sabram.upb.specs.lido.AttrDefsOpt;
import de.sabram.upb.specs.lido.AttrName;
import de.sabram.upb.specs.lido.AttrNames;
import de.sabram.upb.specs.lido.AttrUseId;
import de.sabram.upb.specs.lido.AttributeGrammar;
import de.sabram.upb.specs.lido.ChainName;
import de.sabram.upb.specs.lido.ChainNames;
import de.sabram.upb.specs.lido.CompPart;
import de.sabram.upb.specs.lido.Computations;
import de.sabram.upb.specs.lido.DepAttrs;
import de.sabram.upb.specs.lido.Expression;
import de.sabram.upb.specs.lido.InheritSyms;
import de.sabram.upb.specs.lido.LidoPackage;
import de.sabram.upb.specs.lido.Loop;
import de.sabram.upb.specs.lido.Params;
import de.sabram.upb.specs.lido.ParamsOpt;
import de.sabram.upb.specs.lido.RemoteAttrs;
import de.sabram.upb.specs.lido.RhsAttrs;
import de.sabram.upb.specs.lido.RuleId;
import de.sabram.upb.specs.lido.RuleSpec;
import de.sabram.upb.specs.lido.RuleSpecId;
import de.sabram.upb.specs.lido.ShieldClause;
import de.sabram.upb.specs.lido.ShieldSyms;
import de.sabram.upb.specs.lido.Subtree;
import de.sabram.upb.specs.lido.SymOcc;
import de.sabram.upb.specs.lido.SymbolDefId;
import de.sabram.upb.specs.lido.SymbolDefIds;
import de.sabram.upb.specs.lido.SymbolId;
import de.sabram.upb.specs.lido.SymbolRef;
import de.sabram.upb.specs.lido.SyntId;
import de.sabram.upb.specs.lido.SyntLit;
import de.sabram.upb.specs.lido.SyntUnits;
import de.sabram.upb.specs.lido.TypeId;
import de.sabram.upb.specs.services.LidoGrammarAccess;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.serializer.acceptor.ISemanticSequenceAcceptor;
import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
import org.eclipse.xtext.serializer.diagnostic.ISemanticSequencerDiagnosticProvider;
import org.eclipse.xtext.serializer.diagnostic.ISerializationDiagnostic.Acceptor;
import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.GenericSequencer;
import org.eclipse.xtext.serializer.sequencer.ISemanticNodeProvider.INodesForEObjectProvider;
import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;

@SuppressWarnings("all")
public class LidoSemanticSequencer extends AbstractDelegatingSemanticSequencer {

	@Inject
	private LidoGrammarAccess grammarAccess;
	
	public void createSequence(EObject context, EObject semanticObject) {
		if(semanticObject.eClass().getEPackage() == LidoPackage.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) {
			case LidoPackage.ALT:
				if(context == grammarAccess.getAltRule()) {
					sequence_Alt(context, (Alt) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.ALTS:
				if(context == grammarAccess.getAltsRule()) {
					sequence_Alts(context, (Alts) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.ATTR:
				if(context == grammarAccess.getAttrRule() ||
				   context == grammarAccess.getDefAttrRule() ||
				   context == grammarAccess.getDepAttrRule() ||
				   context == grammarAccess.getDepClauseRule() ||
				   context == grammarAccess.getDependenceRule()) {
					sequence_Attr(context, (Attr) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getAttrCompRule() ||
				   context == grammarAccess.getComputationRule() ||
				   context == grammarAccess.getComputeRule()) {
					sequence_Attr_AttrComp(context, (Attr) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.ATTR_DEF_ID:
				if(context == grammarAccess.getAttrDefIdRule()) {
					sequence_AttrDefId(context, (AttrDefId) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.ATTR_DEF_IDS:
				if(context == grammarAccess.getAttrDefIdsRule()) {
					sequence_AttrDefIds(context, (AttrDefIds) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getAttrDefRule()) {
					sequence_AttrDef_AttrDefIds(context, (AttrDefIds) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.ATTR_DEFS:
				if(context == grammarAccess.getAttrDefsRule()) {
					sequence_AttrDefs(context, (AttrDefs) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.ATTR_DEFS_OPT:
				if(context == grammarAccess.getAttrDefsOptRule()) {
					sequence_AttrDefsOpt(context, (AttrDefsOpt) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.ATTR_NAME:
				if(context == grammarAccess.getAttrNameRule()) {
					sequence_AttrName(context, (AttrName) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.ATTR_NAMES:
				if(context == grammarAccess.getAttrNamesRule()) {
					sequence_AttrNames(context, (AttrNames) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getAttrSpecRule() ||
				   context == grammarAccess.getSpecificationRule() ||
				   context == grammarAccess.getSpecificationsRule()) {
					sequence_AttrNames_AttrSpec(context, (AttrNames) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.ATTR_USE_ID:
				if(context == grammarAccess.getAttrUseIdRule()) {
					sequence_AttrUseId(context, (AttrUseId) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.ATTRIBUTE_GRAMMAR:
				if(context == grammarAccess.getAttributeGrammarRule()) {
					sequence_AttributeGrammar(context, (AttributeGrammar) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.CHAIN_NAME:
				if(context == grammarAccess.getChainNameRule()) {
					sequence_ChainName(context, (ChainName) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.CHAIN_NAMES:
				if(context == grammarAccess.getChainNamesRule()) {
					sequence_ChainNames(context, (ChainNames) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getChainSpecRule() ||
				   context == grammarAccess.getSpecificationRule() ||
				   context == grammarAccess.getSpecificationsRule()) {
					sequence_ChainNames_ChainSpec(context, (ChainNames) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.COMP_PART:
				if(context == grammarAccess.getCompPartRule()) {
					sequence_CompPart(context, (CompPart) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.COMPUTATIONS:
				if(context == grammarAccess.getComputationsRule()) {
					sequence_Computations(context, (Computations) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.DEP_ATTRS:
				if(context == grammarAccess.getDepAttrsRule() ||
				   context == grammarAccess.getDepClauseRule() ||
				   context == grammarAccess.getDependenceRule()) {
					sequence_DepAttrs(context, (DepAttrs) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.EXPRESSION:
				if(context == grammarAccess.getExpressionRule()) {
					sequence_Expression(context, (Expression) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getComputationRule() ||
				   context == grammarAccess.getComputeRule() ||
				   context == grammarAccess.getExpressionDepRule() ||
				   context == grammarAccess.getParamRule() ||
				   context == grammarAccess.getPlainCompRule()) {
					sequence_Expression_ExpressionDep(context, (Expression) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.INHERIT_SYMS:
				if(context == grammarAccess.getInheritOptRule() ||
				   context == grammarAccess.getInheritSymsRule()) {
					sequence_InheritSyms(context, (InheritSyms) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.LOOP:
				if(context == grammarAccess.getComputationRule() ||
				   context == grammarAccess.getComputeRule() ||
				   context == grammarAccess.getLoopRule() ||
				   context == grammarAccess.getPlainCompRule()) {
					sequence_Loop(context, (Loop) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.PARAMS:
				if(context == grammarAccess.getParamsRule()) {
					sequence_Params(context, (Params) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.PARAMS_OPT:
				if(context == grammarAccess.getParamsOptRule()) {
					sequence_ParamsOpt(context, (ParamsOpt) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.REMOTE_ATTRS:
				if(context == grammarAccess.getDepAttrRule() ||
				   context == grammarAccess.getDepClauseRule() ||
				   context == grammarAccess.getDependenceRule() ||
				   context == grammarAccess.getRemoteAttrsRule() ||
				   context == grammarAccess.getRemoteClauseRule() ||
				   context == grammarAccess.getRemoteExpressionRule()) {
					sequence_RemoteAttrs(context, (RemoteAttrs) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.RHS_ATTRS:
				if(context == grammarAccess.getDepAttrRule() ||
				   context == grammarAccess.getDepClauseRule() ||
				   context == grammarAccess.getDependenceRule() ||
				   context == grammarAccess.getRhsAttrsRule()) {
					sequence_RhsAttrs(context, (RhsAttrs) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.RULE_ID:
				if(context == grammarAccess.getRuleIdRule()) {
					sequence_RuleId(context, (RuleId) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.RULE_SPEC:
				if(context == grammarAccess.getRuleSpecRule() ||
				   context == grammarAccess.getSpecificationRule() ||
				   context == grammarAccess.getSpecificationsRule()) {
					sequence_RuleSpec(context, (RuleSpec) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.RULE_SPEC_ID:
				if(context == grammarAccess.getRuleSpecIdRule()) {
					sequence_RuleSpecId(context, (RuleSpecId) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.SHIELD_CLAUSE:
				if(context == grammarAccess.getShieldRule() ||
				   context == grammarAccess.getShieldClauseRule()) {
					sequence_ShieldClause(context, (ShieldClause) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.SHIELD_SYMS:
				if(context == grammarAccess.getShieldSymsRule()) {
					sequence_ShieldSyms(context, (ShieldSyms) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.SUBTREE:
				if(context == grammarAccess.getDepAttrRule() ||
				   context == grammarAccess.getDepClauseRule() ||
				   context == grammarAccess.getDependenceRule() ||
				   context == grammarAccess.getRemoteExpressionRule()) {
					sequence_RemoteExpression_Subtree(context, (Subtree) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getSubtreeRule()) {
					sequence_Subtree(context, (Subtree) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.SYM_OCC:
				if(context == grammarAccess.getSymOccRule()) {
					sequence_SymOcc(context, (SymOcc) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.SYMBOL_DEF_ID:
				if(context == grammarAccess.getSpecificationRule() ||
				   context == grammarAccess.getSpecificationsRule() ||
				   context == grammarAccess.getSymCompSpecRule()) {
					sequence_SymCompSpec_SymbolDefId(context, (SymbolDefId) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getSymbolDefIdRule()) {
					sequence_SymbolDefId(context, (SymbolDefId) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.SYMBOL_DEF_IDS:
				if(context == grammarAccess.getSymAttrSpecRule()) {
					sequence_SymAttrSpec_SymbolDefIds(context, (SymbolDefIds) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getSymbolDefIdsRule()) {
					sequence_SymbolDefIds(context, (SymbolDefIds) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getSpecificationRule() ||
				   context == grammarAccess.getSpecificationsRule() ||
				   context == grammarAccess.getTermSpecRule()) {
					sequence_SymbolDefIds_TermSpec(context, (SymbolDefIds) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.SYMBOL_ID:
				if(context == grammarAccess.getDepAttrRule() ||
				   context == grammarAccess.getDepClauseRule() ||
				   context == grammarAccess.getDependenceRule() ||
				   context == grammarAccess.getRemoteAttrRule() ||
				   context == grammarAccess.getRemoteClauseRule() ||
				   context == grammarAccess.getRemoteExpressionRule()) {
					sequence_RemoteAttr_SymbolId(context, (SymbolId) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getInheritSymRule() ||
				   context == grammarAccess.getShieldSymRule() ||
				   context == grammarAccess.getSymbolIdRule()) {
					sequence_SymbolId(context, (SymbolId) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.SYMBOL_REF:
				if(context == grammarAccess.getSymbolRefRule()) {
					sequence_SymbolRef(context, (SymbolRef) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.SYNT_ID:
				if(context == grammarAccess.getProductionRule()) {
					sequence_Production_SyntId(context, (SyntId) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getSyntIdRule() ||
				   context == grammarAccess.getSyntUnitRule()) {
					sequence_SyntId(context, (SyntId) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.SYNT_LIT:
				if(context == grammarAccess.getSyntLitRule() ||
				   context == grammarAccess.getSyntUnitRule()) {
					sequence_SyntLit(context, (SyntLit) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.SYNT_UNITS:
				if(context == grammarAccess.getSyntUnitsRule()) {
					sequence_SyntUnits(context, (SyntUnits) semanticObject); 
					return; 
				}
				else break;
			case LidoPackage.TYPE_ID:
				if(context == grammarAccess.getExpandOptRule() ||
				   context == grammarAccess.getTypeIdRule()) {
					sequence_TypeId(context, (TypeId) semanticObject); 
					return; 
				}
				else break;
			}
		if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
	}
	
	/**
	 * Constraint:
	 *     (syntId=SyntId?)
	 */
	protected void sequence_Alt(EObject context, Alt semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (alts+=Alt alts+=Alt*)
	 */
	protected void sequence_Alts(EObject context, Alts semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_AttrDefId(EObject context, AttrDefId semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, LidoPackage.Literals.ATTR_DEF_ID__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, LidoPackage.Literals.ATTR_DEF_ID__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getAttrDefIdAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (attrDefIds+=AttrDefId attrDefIds+=AttrDefId*)
	 */
	protected void sequence_AttrDefIds(EObject context, AttrDefIds semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (attrDefIds+=AttrDefId attrDefIds+=AttrDefId* typeId=TypeId)
	 */
	protected void sequence_AttrDef_AttrDefIds(EObject context, AttrDefIds semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (attrDefs=AttrDefs?)
	 */
	protected void sequence_AttrDefsOpt(EObject context, AttrDefsOpt semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (attrDefs+=AttrDef attrDefs+=AttrDef*)
	 */
	protected void sequence_AttrDefs(EObject context, AttrDefs semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_AttrName(EObject context, AttrName semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, LidoPackage.Literals.ATTR_NAME__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, LidoPackage.Literals.ATTR_NAME__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getAttrNameAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (attrNames+=AttrName attrNames+=AttrName*)
	 */
	protected void sequence_AttrNames(EObject context, AttrNames semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (attrNames+=AttrName attrNames+=AttrName* typeId=TypeId)
	 */
	protected void sequence_AttrNames_AttrSpec(EObject context, AttrNames semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_AttrUseId(EObject context, AttrUseId semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, LidoPackage.Literals.ATTR_USE_ID__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, LidoPackage.Literals.ATTR_USE_ID__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getAttrUseIdAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     ((symOcc=SymOcc attrUseId=AttrUseId) | attrUseId=AttrUseId)
	 */
	protected void sequence_Attr(EObject context, Attr semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (((symOcc=SymOcc attrUseId=AttrUseId) | attrUseId=AttrUseId) expressionDep=ExpressionDep)
	 */
	protected void sequence_Attr_AttrComp(EObject context, Attr semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     specifications+=Specifications*
	 */
	protected void sequence_AttributeGrammar(EObject context, AttributeGrammar semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_ChainName(EObject context, ChainName semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, LidoPackage.Literals.CHAIN_NAME__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, LidoPackage.Literals.CHAIN_NAME__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getChainNameAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (chainNames+=ChainName chainNames+=ChainName*)
	 */
	protected void sequence_ChainNames(EObject context, ChainNames semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (chainNames+=ChainName chainNames+=ChainName* typeId=TypeId)
	 */
	protected void sequence_ChainNames_ChainSpec(EObject context, ChainNames semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (computations=Computations?)
	 */
	protected void sequence_CompPart(EObject context, CompPart semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (computations+=Computation computations+=Computation*)
	 */
	protected void sequence_Computations(EObject context, Computations semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (depAttrs+=DepAttr depAttrs+=DepAttr*)
	 */
	protected void sequence_DepAttrs(EObject context, DepAttrs semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((attr=Attr | rhsAttrs=RhsAttrs | (name=ID params=ParamsOpt) | remoteExpression=RemoteExpression | symbolRef=SymbolRef)?)
	 */
	protected void sequence_Expression(EObject context, Expression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((attr=Attr | rhsAttrs=RhsAttrs | (name=ID params=ParamsOpt) | remoteExpression=RemoteExpression | symbolRef=SymbolRef)? depClause=DepClause?)
	 */
	protected void sequence_Expression_ExpressionDep(EObject context, Expression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (inheritSyms+=InheritSym inheritSyms+=InheritSym*)
	 */
	protected void sequence_InheritSyms(EObject context, InheritSyms semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (expressionDep=ExpressionDep attr=Attr expressionDep_right=ExpressionDep)
	 */
	protected void sequence_Loop(EObject context, Loop semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, LidoPackage.Literals.LOOP__EXPRESSION_DEP) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, LidoPackage.Literals.LOOP__EXPRESSION_DEP));
			if(transientValues.isValueTransient(semanticObject, LidoPackage.Literals.LOOP__ATTR) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, LidoPackage.Literals.LOOP__ATTR));
			if(transientValues.isValueTransient(semanticObject, LidoPackage.Literals.LOOP__EXPRESSION_DEP_RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, LidoPackage.Literals.LOOP__EXPRESSION_DEP_RIGHT));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getLoopAccess().getExpressionDepExpressionDepParserRuleCall_1_0(), semanticObject.getExpressionDep());
		feeder.accept(grammarAccess.getLoopAccess().getAttrAttrParserRuleCall_3_0(), semanticObject.getAttr());
		feeder.accept(grammarAccess.getLoopAccess().getExpressionDep_rightExpressionDepParserRuleCall_5_0(), semanticObject.getExpressionDep_right());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (params=Params?)
	 */
	protected void sequence_ParamsOpt(EObject context, ParamsOpt semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (params+=Param params+=Param*)
	 */
	protected void sequence_Params(EObject context, Params semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID syntUnits=SyntUnits)
	 */
	protected void sequence_Production_SyntId(EObject context, SyntId semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID attrUseId=AttrUseId)
	 */
	protected void sequence_RemoteAttr_SymbolId(EObject context, SymbolId semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, LidoPackage.Literals.SYMBOL_ID__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, LidoPackage.Literals.SYMBOL_ID__NAME));
			if(transientValues.isValueTransient(semanticObject, LidoPackage.Literals.SYMBOL_ID__ATTR_USE_ID) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, LidoPackage.Literals.SYMBOL_ID__ATTR_USE_ID));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getSymbolIdAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getRemoteAttrAccess().getAttrUseIdAttrUseIdParserRuleCall_2_0(), semanticObject.getAttrUseId());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (remoteAttrs+=RemoteAttr remoteAttrs+=RemoteAttr*)
	 */
	protected void sequence_RemoteAttrs(EObject context, RemoteAttrs semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (symOcc=SymOcc? remoteClause=RemoteClause shield=Shield? expandOpt=ExpandOpt?)
	 */
	protected void sequence_RemoteExpression_Subtree(EObject context, Subtree semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_RhsAttrs(EObject context, RhsAttrs semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, LidoPackage.Literals.RHS_ATTRS__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, LidoPackage.Literals.RHS_ATTRS__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getRhsAttrsAccess().getNameIDTerminalRuleCall_2_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_RuleId(EObject context, RuleId semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, LidoPackage.Literals.RULE_ID__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, LidoPackage.Literals.RULE_ID__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getRuleIdAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (ruleId=RuleId?)
	 */
	protected void sequence_RuleSpecId(EObject context, RuleSpecId semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (ruleSpecId=RuleSpecId production=Production compPart=CompPart?)
	 */
	protected void sequence_RuleSpec(EObject context, RuleSpec semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((shieldSym=ShieldSym | shieldSym=ShieldSyms)?)
	 */
	protected void sequence_ShieldClause(EObject context, ShieldClause semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (shieldSyms+=ShieldSym shieldSyms+=ShieldSym*)
	 */
	protected void sequence_ShieldSyms(EObject context, ShieldSyms semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (symOcc=SymOcc?)
	 */
	protected void sequence_Subtree(EObject context, Subtree semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (symbolDefIds+=SymbolDefId symbolDefIds+=SymbolDefId* attrDefsOpt=AttrDefsOpt)
	 */
	protected void sequence_SymAttrSpec_SymbolDefIds(EObject context, SymbolDefIds semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=ID inheritOpt=InheritOpt? compPart=CompPart?)
	 */
	protected void sequence_SymCompSpec_SymbolDefId(EObject context, SymbolDefId semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (symbolId=SymbolId?)
	 */
	protected void sequence_SymOcc(EObject context, SymOcc semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_SymbolDefId(EObject context, SymbolDefId semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (symbolDefIds+=SymbolDefId symbolDefIds+=SymbolDefId*)
	 */
	protected void sequence_SymbolDefIds(EObject context, SymbolDefIds semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (symbolDefIds+=SymbolDefId symbolDefIds+=SymbolDefId* typeId=TypeId)
	 */
	protected void sequence_SymbolDefIds_TermSpec(EObject context, SymbolDefIds semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_SymbolId(EObject context, SymbolId semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (symbolId=SymbolId?)
	 */
	protected void sequence_SymbolRef(EObject context, SymbolRef semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_SyntId(EObject context, SyntId semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=STRING
	 */
	protected void sequence_SyntLit(EObject context, SyntLit semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, LidoPackage.Literals.SYNT_UNIT__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, LidoPackage.Literals.SYNT_UNIT__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getSyntLitAccess().getNameSTRINGTerminalRuleCall_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Constraint:
	 *     (syntUnits+=SyntUnit*)
	 */
	protected void sequence_SyntUnits(EObject context, SyntUnits semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=ID
	 */
	protected void sequence_TypeId(EObject context, TypeId semanticObject) {
		if(errorAcceptor != null) {
			if(transientValues.isValueTransient(semanticObject, LidoPackage.Literals.TYPE_ID__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, LidoPackage.Literals.TYPE_ID__NAME));
		}
		INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
		SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
		feeder.accept(grammarAccess.getTypeIdAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
		feeder.finish();
	}
}
